home *** CD-ROM | disk | FTP | other *** search
/ Euroscene 1 / Euroscene 1.iso / resource / midi2tex.lha / Midi2TeX / src / tp_heap1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-24  |  8.9 KB  |  423 lines
  1. /* Output from p2c, the Pascal-to-C translator */
  2. /* From input file "tp_heap1.pas" */
  3.  
  4.  
  5. #define TP_HEAP1_G
  6. #include "tp_heap1.h"
  7. /*
  8. #ifndef THINK_C
  9. #include "conio.h"
  10. #endif
  11. */
  12. #ifdef __TURBOC__
  13. #include "conio.h"
  14. #endif
  15.  
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. /**********************************************************/
  20. boolean Empty(ThisList)
  21. HeapRecord ThisList;
  22. {
  23.   /**********************************************************/
  24.   /* Empty:=ThisList.Tail=nil; */
  25.   /* does not work properly yet, FIX !! */
  26.   return (ThisList.Size == 0);
  27. }
  28.  
  29.  
  30. /********************************************************************/
  31. Void InsertOnTop(ThisList, N)
  32. HeapRecord *ThisList;
  33. NoteRecord *N;
  34. {
  35.   /********************************************************************/
  36.   if (ThisList->Tail == NULL) {
  37.     ThisList->Tail = N;
  38.     N->Next = N;
  39.     N->Prev = N;
  40.   } else {
  41.     N->Next = ThisList->Tail->Next;
  42.     N->Prev = ThisList->Tail;
  43.     ThisList->Tail->Next->Prev = N;
  44.     ThisList->Tail->Next = N;
  45.   }
  46.   ThisList->Size++;
  47. }
  48.  
  49.  
  50. /**********************************************************/
  51. Void Append(ThisList, N)
  52. HeapRecord *ThisList;
  53. NoteRecord *N;
  54. {
  55.   /**********************************************************/
  56.   if (ThisList->Tail == NULL) {
  57.     ThisList->Tail = N;
  58.     N->Next = N;
  59.     N->Prev = N;
  60.   } else {
  61.     N->Prev = ThisList->Tail;
  62.     N->Next = ThisList->Tail->Next;
  63.     ThisList->Tail->Next->Prev = N;
  64.     ThisList->Tail->Next = N;
  65.     ThisList->Tail = N;
  66.   }
  67.   ThisList->Size++;
  68. }
  69.  
  70.  
  71. /*****************************************************************/
  72. Void Insert(ThisList, Nin, N)
  73. HeapRecord *ThisList;
  74. NoteRecord *Nin, *N;
  75. {
  76.   /* inserts N BEFORE Nin !!                                       */
  77.   /*****************************************************************/
  78.   if (ThisList->Tail == NULL) {   /* NoteList is empty */
  79.     InsertOnTop(ThisList, N);
  80.     return;
  81.   }
  82.   /* with */
  83.   if (Nin == ThisList->Tail->Next)
  84.   {   /* N should be inserted in front of the first item in list ...*/
  85.     /* Append(ThisList,N) */
  86.     InsertOnTop(ThisList, N);
  87.     return;
  88.   }
  89.   Nin->Prev->Next = N;
  90.   N->Prev = Nin->Prev;
  91.   Nin->Prev = N;
  92.   N->Next = Nin;
  93.   ThisList->Size++;
  94. }
  95.  
  96.  
  97. /**************************************************************/
  98. Void Re_move(ThisList, N)
  99. HeapRecord *ThisList;
  100. NoteRecord *N;
  101. {
  102.   /**************************************************************/
  103.   NoteRecord *P;
  104.  
  105.   if (ThisList->Tail != NULL) {
  106.     P = ThisList->Tail;   /* pointer to Tail */
  107.     while (P->Next != N && P->Next != ThisList->Tail)
  108.       P = P->Next;
  109.     if (P->Next == N) {
  110.       P->Next = N->Next;
  111.       N->Next->Prev = P;
  112.       if (ThisList->Tail == N) {
  113.     if (P == N)
  114.       ThisList->Tail = NULL;
  115.     else
  116.       ThisList->Tail = N->Prev;
  117.       }
  118.     }  /* if */
  119.   }  /* if */
  120.   ThisList->Size--;   /* with */
  121. }
  122.  
  123.  
  124. /*****************************************************/
  125. Void FirstNote(ThisList, N)
  126. HeapRecord ThisList;
  127. NoteRecord **N;
  128. {
  129.   /*****************************************************/
  130.   Char c;
  131.  
  132.   *N = ThisList.Tail->Next;
  133. #ifdef __TURBOC__
  134.   if (!kbhit())
  135.     return;
  136.   c = getch();
  137.   if (c == 'q')
  138.     ErrorExit(17L);
  139. #endif
  140. }
  141.  
  142.  
  143. /*****************************************************/
  144. Void LastNote(ThisList, N)
  145. HeapRecord ThisList;
  146. NoteRecord **N;
  147. {
  148.   /*****************************************************/
  149.   Char c;
  150.  
  151.   *N = ThisList.Tail;
  152. #ifdef __TURBOC__
  153.   if (!kbhit())
  154.     return;
  155.   c = getch();
  156.   if (c == 'q')
  157.     ErrorExit(17L);
  158. #endif
  159. }
  160.  
  161.  
  162. /*****************************************************/
  163. Void NextNote(N, P)
  164. NoteRecord *N, **P;
  165. {
  166.   /*****************************************************/
  167.   Char c;
  168.  
  169.   *P = N->Next;
  170. #ifdef __TURBOC__
  171.   if (!kbhit())
  172.     return;
  173.   c = getch();
  174.   if (c == 'q')
  175.     ErrorExit(17L);
  176. #endif
  177. }
  178.  
  179.  
  180. /*****************************************************/
  181. Void PrevNote(N, P)
  182. NoteRecord *N, **P;
  183. {
  184.   /*****************************************************/
  185.   *P = N->Prev;
  186. }
  187.  
  188.  
  189. /***************************************************/
  190. Void ResetNoteRec(N)
  191. NoteRecord *N;
  192. {
  193.   /***************************************************/
  194.   memset(N, 0, sizeof(NoteRecord));
  195. }
  196.  
  197.  
  198. /*****************************************************/
  199. NoteRecord *GetFreeNote()
  200. {
  201.   /*****************************************************/
  202.   NoteRecord *N;
  203.  
  204.   if (NotePool.Size <= 0) {
  205.     ErrorExit(10L);
  206.     return N;
  207.   }
  208.   N = NotePool.Tail;
  209.   Re_move(&NotePool, N);
  210.   ResetNoteRec(N);
  211.   return N;
  212. }
  213.  
  214.  
  215. /*****************************************************/
  216. Void BringFreeNote(N)
  217. NoteRecord *N;
  218. {
  219.   /*****************************************************/
  220.   Append(&NotePool, N);
  221. }
  222.  
  223.  
  224. /*************************************************************/
  225. boolean EqualsNote(NoteRecord *N, uchar ThisNote)
  226. {
  227.   /*************************************************************/
  228.   if (N->NoteVal == ThisNote)
  229.     return true;
  230.   else
  231.     return false;
  232. }
  233.  
  234.  
  235. #define POOLSIZE        200
  236.  
  237.  
  238. /*************************/
  239. Void InitNotePool()
  240. {
  241.   /*************************/
  242.   NoteRecord *N;
  243.  
  244.   for (i = 1; i <= POOLSIZE; i++) {
  245.     N = (NoteRecord *)malloc(sizeof(NoteRecord));
  246.     if (N==NULL) ErrorExit(9L);
  247.     Append(&NotePool, N);
  248.   }
  249. }  /* InitNotePool */
  250.  
  251. #undef POOLSIZE
  252.  
  253.  
  254. /*************************/
  255. Void KillNotePool()
  256. {
  257.   /*************************/
  258.   KillList(&NotePool);
  259. }
  260.  
  261.  
  262. /*************************/
  263. Void KillNoteLists()
  264. {
  265.   /*************************/
  266.   long I;
  267.   TrackRecord *WITH;
  268.  
  269.   for (I = 0; I <= 15; I++) {
  270.     WITH = &TrackArray[I];
  271.     if (WITH->NoteList.Tail != NULL)
  272.       KillList(&WITH->NoteList);
  273.     WITH = &TrackArray[I];
  274.     if (WITH->SpillList.Tail != NULL)
  275.       KillList(&WITH->SpillList);
  276.   }
  277.   KillList(&NotePool);
  278. }
  279.  
  280.  
  281. /***********************************************/
  282. Void KillList(ThisList)
  283. HeapRecord *ThisList;
  284. {
  285.   /***********************************************/
  286.   NoteRecord *N, *P;
  287.  
  288.   LastNote(*ThisList, &P);
  289.   while (!Empty(*ThisList)) {
  290.     N = P->Next;
  291.     Re_move(ThisList, N);
  292. /* p2c: tp_heap1.pas, line 263:
  293.  * Warning: Too many arguments for freemem [299] */
  294.     free(N);
  295.   }
  296. }  /* InitNoteHeap */
  297.  
  298.  
  299. /***********************************************************/
  300. Char *NoteList2String(Result, ThisList)
  301. Char *Result;
  302. HeapRecord ThisList;
  303. {
  304.   /***********************************************************/
  305.   Char Tmpstr[256], tmp[256];
  306.   NoteRecord *N, *P;
  307.  
  308.   N = ThisList.Tail->Next;
  309.   P = N;
  310.   *Tmpstr = '\0';
  311.   do {
  312.     switch (N->Event) {
  313.  
  314.     case NOTEON:
  315.     case NOTEOFF:
  316.       sprintf(tmp, "%d", N->NoteVal);
  317.       sprintf(Tmpstr + strlen(Tmpstr), "%s ", tmp);
  318.       break;
  319.  
  320.     default:
  321.       strcat(Tmpstr, "n ");
  322.       break;
  323.     }
  324.     NextNote(N, &N);
  325.   } while (N != P);
  326.   strcpy(Result, Tmpstr);
  327.   return Result;
  328. }
  329.  
  330.  
  331. /***********************************************************/
  332. Char *ChordNoteList2String(Result, ThisList)
  333. Char *Result;
  334. HeapRecord ThisList;
  335. {
  336.   /***********************************************************/
  337.   Char Tmpstr[256], tmp[256];
  338.   NoteRecord *N, *P;
  339.  
  340.   N = ThisList.Tail->Next;
  341.   P = N;
  342.   *Tmpstr = '\0';
  343.   do {
  344.     switch (N->Event) {
  345.  
  346.     case NOTEON:
  347.     case NOTEOFF:
  348.       sprintf(tmp, "%d", N->NoteVal);
  349.       if (N->ChordNote)
  350.     strcat(Tmpstr, "-- ");
  351.       else
  352.     sprintf(Tmpstr + strlen(Tmpstr), "%s ", tmp);
  353.       break;
  354.  
  355.     default:
  356.       strcat(Tmpstr, "n ");
  357.       break;
  358.     }
  359.     NextNote(N, &N);
  360.   } while (N != P);
  361.   strcpy(Result, Tmpstr);
  362.   return Result;
  363. }
  364.  
  365.  
  366. /*************************************************/
  367. Void Exchange(ThisList, N1, N2)
  368. HeapRecord *ThisList;
  369. NoteRecord **N1, **N2;
  370. {
  371.   /*************************************************/
  372.   NoteRecord *P1, *P2, *F;
  373.  
  374.   F = ThisList->Tail->Next;   /* first item in notelist */
  375.   NextNote(*N1, &P1);
  376.   NextNote(*N2, &P2);
  377.   if (P1 == *N2) {
  378.     if (P2 == *N1) {   /* only two notes in the list */
  379.       NextNote(ThisList->Tail, &ThisList->Tail);
  380.       return;
  381.     }
  382.     Re_move(ThisList, *N2);
  383.     /*If N1=F Then Append(ThisList,N2) Else */
  384.     Insert(ThisList, *N1, *N2);
  385.     Re_move(ThisList, *N1);
  386.     if (P2 == F)
  387.       Append(ThisList, *N1);
  388.     else
  389.       Insert(ThisList, P2, *N1);
  390.     return;
  391.   }
  392.   Re_move(ThisList, *N1);
  393.   /* If N2=F Then Append(ThisList,N1) Else */
  394.   Insert(ThisList, *N2, *N1);
  395.   Re_move(ThisList, *N2);
  396.   if (P1 == F)
  397.     Append(ThisList, *N2);
  398.   else
  399.     Insert(ThisList, P1, *N2);
  400. }  /* exchange */
  401.  
  402.  
  403. void _TP_Heap1_init()
  404. {
  405.   HeapRecord *WITH;
  406.  
  407.   static int _was_initialized = 0;
  408.   if (_was_initialized++)
  409.     return;
  410.   NotePool.Tail = NULL;
  411.   NotePool.Size = 0;
  412.   for (i = 1; i <= 16; i++) {
  413.     WITH = &TrackArray[i - 1].NoteList;
  414.     WITH->Size = 0;
  415.     WITH->Tail = NULL;
  416.     WITH = &TrackArray[i - 1].SpillList;
  417.     WITH->Size = 0;
  418.     WITH->Tail = NULL;
  419.   }
  420. }
  421.  
  422. /* End. */
  423.